/**
 * 工具函数库
 */

/**
 * 生成随机ID
 * @param {number} length ID长度
 * @returns {string} 生成的ID
 */
export function generateId(length = 8) {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  let result = '';
  for (let i = 0; i < length; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length));
  }
  return result;
}

/**
 * 深拷贝对象
 * @param {any} obj 要拷贝的对象
 * @returns {any} 拷贝后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj;
  if (obj instanceof Date) return new Date(obj.getTime());
  if (obj instanceof Array) return obj.map(item => deepClone(item));
  if (obj instanceof Object) {
    const clonedObj = {};
    Object.keys(obj).forEach(key => {
      clonedObj[key] = deepClone(obj[key]);
    });
    return clonedObj;
  }
}

/**
 * 防抖函数
 * @param {Function} func 要防抖的函数
 * @param {number} wait 等待时间
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, wait) {
  let timeout;
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout);
      func(...args);
    };
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
}

/**
 * 节流函数
 * @param {Function} func 要节流的函数
 * @param {number} limit 时间限制
 * @returns {Function} 节流后的函数
 */
export function throttle(func, limit) {
  let inThrottle;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

/**
 * 格式化文件大小
 * @param {number} bytes 字节数
 * @returns {string} 格式化后的文件大小
 */
export function formatFileSize(bytes) {
  if (bytes === 0) return '0 Bytes';
  const k = 1024;
  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
}

/**
 * 验证邮箱格式
 * @param {string} email 邮箱地址
 * @returns {boolean} 是否有效
 */
export function validateEmail(email) {
  const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return re.test(email);
}

/**
 * 验证手机号格式
 * @param {string} phone 手机号
 * @returns {boolean} 是否有效
 */
export function validatePhone(phone) {
  const re = /^1[3-9]\d{9}$/;
  return re.test(phone);
}

/**
 * 生成唯一编码
 * @param {string} prefix 前缀
 * @returns {string} 唯一编码
 */
export function generateUniqueCode(prefix = '') {
  const timestamp = new Date().getTime().toString(36);
  const randomStr = Math.random().toString(36).substr(2, 5);
  return `${prefix}${timestamp}${randomStr}`.toUpperCase();
}

/**
 * 数组去重
 * @param {Array} array 数组
 * @param {string} key 对象键名（可选）
 * @returns {Array} 去重后的数组
 */
export function uniqueArray(array, key = null) {
  if (key) {
    const seen = new Set();
    return array.filter(item => {
      const value = item[key];
      if (seen.has(value)) {
        return false;
      }
      seen.add(value);
      return true;
    });
  }
  return [...new Set(array)];
}

/**
 * 对象数组排序
 * @param {Array} array 对象数组
 * @param {string} key 排序键名
 * @param {string} order 排序方式 'asc' | 'desc'
 * @returns {Array} 排序后的数组
 */
export function sortByKey(array, key, order = 'asc') {
  return array.sort((a, b) => {
    let aVal = a[key];
    let bVal = b[key];
    
    if (typeof aVal === 'string') aVal = aVal.toLowerCase();
    if (typeof bVal === 'string') bVal = bVal.toLowerCase();
    
    if (aVal < bVal) return order === 'asc' ? -1 : 1;
    if (aVal > bVal) return order === 'asc' ? 1 : -1;
    return 0;
  });
}

export function formatDate(date, format = 'YYYY-MM-DD') {
  if (!date) return ''
  const d = new Date(date)
  const year = d.getFullYear()
  const month = String(d.getMonth() + 1).padStart(2, '0')
  const day = String(d.getDate()).padStart(2, '0')
  return format.replace('YYYY', year).replace('MM', month).replace('DD', day)
}

// 参数配置工具
export function getAllParamItems(paramGroups) {
  const params = []
  
  function extractParams(groups) {
    groups.forEach(group => {
      if (group.paramItems) {
        params.push(...group.paramItems)
      }
      if (group.childGroups) {
        extractParams(group.childGroups)
      }
    })
  }
  
  if (paramGroups) {
    extractParams(paramGroups)
  }
  
  return params
}

export function findParamByCode(paramCode, paramGroups) {
  const allParams = getAllParamItems(paramGroups)
  return allParams.find(param => param.paramCode === paramCode)
}

// 计算表达式解析
export function evaluateExpression(expr, context) {
  try {
    // 简单的表达式计算，实际项目中可以使用更安全的表达式计算库
    const func = new Function(...Object.keys(context), `return ${expr}`)
    return func(...Object.values(context))
  } catch (error) {
    console.error('表达式计算错误:', error, expr, context)
    return null
  }
}


export default {
  generateId,
  deepClone,
  debounce,
  throttle,
  formatFileSize,
  validateEmail,
  validatePhone,
  generateUniqueCode,
  uniqueArray,
  sortByKey,
  formatDate,
  getAllParamItems,
  findParamByCode,
  evaluateExpression
};